Init + Create + Verify
At Mentaport, we aim to simplify the process for developers and creators to protect the authenticity of their content. We've broken down the process of watermarking, creating a certificate, and verifying it into three simple steps: Init, Create, and Verify.
npm install @mentaport/certificates
Checkout our examples to get started.
Initializing SDK
import { CertificateSDK } from '@mentaport/certificates';
To initialize the Certificate SDK, simply provide your API Key and an optional Environment parameter (the default setting is 'production').
Server Side Applications
For security purposes, we recommend using server-side applications. This way, your API Key will be highly protected. Checkout our examples to get started.
Init SDK in server-side only: (Recommended).
// To call in the server
// Same for just client-only applications
_mentaportSDK = new CertificateSDK(apiKey);
_mentaportSDK.setClientEnv(env?:Environment);
Creating a Certificate
When creating a new certificate, we first watermark the content and approve the provided information. Once approved, the certificate is issued, and the newly watermarked content becomes available for download.
1. Creating a certificate
/**
* Function to crteate a certificte
* @param {ICertificateArg} ICertificateArg
* - @param {contractId} ContractId
* - @param {contentFormat} ContentFormat (png, mp3..)
* - @param {name} Name of certificate
* - @param {username} Public name
* - @param {description} Description of work
* - @param {usingAI} Boolean
* - @param {aiTrainingMiningInfo} AITrainingMiningInfo
* - @param {certId} CertId (optional) Use if updating NonActive certificate
* - @param {aiSoftware} (optional) AI software used
* - @param {aiModel} (optional) AI model used
* - @param {album} (optional) Album name
* - @param {albumYear} (optional) Album year
*
* @param {blobContent} File to uplaod
*
* @returns {IResults<ICertificate>} Returns initializing certificate.
*/
const result = await _mentaportSDK.createCertificate(
initCertificateArgs: ICertificateArg,
blobContent:Blob);
Once the content is uploaded, the status of the certificate will change from 'NonActive' to 'Initialized'.
3. Check status for Pending Certificate
Depending on the type of content you are watermarking (image, audio, video), the watermarking process can vary in time, typically taking about 1-20 seconds. Check the status until the content has successfully been watermarked before proceeding.
/**
* Function to create a watermark certificate
* @param {contractId} ContractId
* @param {certId} certId
*
* @returns {IResults<ICertStatusResult>} Returns certificate and status information.
*/
const result = await _mentaportSDK.getCertificateStatus(contractId:string, certId:string);
Once the content has succesfully been watermarked, the status will change from 'Initialized' to 'Pending'.
4. Approve Certificate
Approve the watermarked content and verify the information provided before creating the blockchain certificate. Once approved, the content will be available for download.
/**
* Function to approve / non-approve a certificate before it generates NFT
*
* @param {contractId} ContractId
* @param {certId} certId from init content call
* @param {approve} Approve boolean
*
* @returns {IResults<ICertificate>} Returns certificate
*/
const result = await _mentaportSDK.approveCertificate(
contractId:string,
certId:string,
approved:boolean);
Once the certificate has been successfully approved, it will be executed on-chain, and the status will change to 'Active.'
5. Download Watermarked Content
Once the certificate has been successfully created, you're all set! Now you can download your newly watermarked content and distribute it fearlessly. Track it and rest assured that wherever it ends up, the provenance and ownership will be secure and traceable!
/**
* Function to get download url of certificate
* @param {contractId} ContractId
* @param {certId} certId
*
* @returns {url} Returns url.
*/
const result = await _mentaportSDK.getDownloadUrl(contractId:string, certId:string);
Verify Content
The Mentaport SDK provides a straightforward method for checking if a piece of content contains a watermark and/or a C2PA manifest.
Start the verification process by uploading your content. Verification times range from approximately 1-20 seconds, depending on the size or length of the file uploaded (image, audio, video). After receiving the initial response, continue to check the status until you receive one of the following responses: 'NoCertificate' or 'Certified'.
/**
* Function to verify if a piece of content has a certificate
* @param {contentFormat} contentFormat
* @param {urlFound} URL of where it was found
* @param {blobContent} content blob
*
* @returns {IResults<IVerify>} Returns verification status
*
*/
const result = await _mentaportSDK.verifyContent(
contentFormat:ContentFormat,
urlFound:string,
blobContent:Blob,
):
/**
* Function to get verification progress status
* @param {verId} Id from verifyContent result
*
* @returns {IVerify} Returns verification status and certificate if found.
*/
const result = await _mentaportSDK.getVerificationStatus(verId:string):
Certificate Analytics
The Mentaport SDK offers a streamlined approach to access and review the analytics and tracking details of a certificate.
/**
* Function to get certificates analytics
* @param {analytics} ICertificateAnalyticsArg
* - @param {queryDateStart} Query start date
* - @param {queryDateEnd} Query end date
* - @param {contractId} ContractId
* - @param {certId} CertId
*
* @returns {ICertificatesQuery} Returns all certificates per contract.
* Each contract certificate will be in its own array
*/
const result = await _mentaportSDK.getCertificatesAnalytic(
analytics:ICertificateAnalyticsArg):
Checkout our examples to get started.